package com.canbot.u05.utils;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.media.ExifInterface;

import java.io.IOException;


public class SystemPhotot {

        /**
         * 默认压缩后图片的宽度（参考值）
         */
        private static final int DEFAULT_WIDTH = 480;

        /**
         * 默认压缩后图片的高度（参考值）
         */
        private static final int DEFAULT_HEIGHT = 800;


        /**
         * 读取图片属性：旋转的角度
         *
         * @param path 图片绝对路径
         * @return degree旋转的角度
         */
        private static int readPictureDegree(String path) {
                int degree = 0;
                try {
                        ExifInterface exifInterface = new ExifInterface(path);
                        int orientation = exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
                        switch (orientation) {
                                case ExifInterface.ORIENTATION_ROTATE_90:
                                        degree = 90;
                                        break;
                                case ExifInterface.ORIENTATION_ROTATE_180:
                                        degree = 180;
                                        break;
                                case ExifInterface.ORIENTATION_ROTATE_270:
                                        degree = 270;
                                        break;
                        }
                }
                catch (IOException e) {
                        e.printStackTrace();
                }
                return degree;
        }

        /**
         * 将图片按照指定的角度进行旋转
         *
         * @param bitmap bitmap
         * @param path   path
         * @return Bitmap
         */
        public static Bitmap rotateBitmapByDegree(Bitmap bitmap, String path) {
                if (bitmap == null) {
                        return null;
                }
                int degree = readPictureDegree(path);
                // 旋转图片 动作
                Matrix matrix = new Matrix();
                matrix.postRotate(degree);
                // 创建新的图片
                // bitmap.recycle();
                return Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
        }



        /**
         * 以默认分辨率（480x800）为基准压缩图片
         *
         * @param srcPath 原文件路径
         * @return 压缩后的图片（Bitmap）
         */
        public static Bitmap getImage(String srcPath) {
                return getImage(srcPath, DEFAULT_WIDTH, DEFAULT_HEIGHT);
        }

        /**
         * 以指定分辨率为基准压缩图片
         *
         * @param srcPath   原文件路径
         * @param imgWidth  压缩后图片的宽度（大概值）
         * @param imgHeight 压缩后图片的高度（大概值）
         * @return 压缩后的图片（Bitmap）
         */
        public static Bitmap getImage(String srcPath, int imgWidth, int imgHeight) {
                return getImage(srcPath, srcPath, imgWidth, imgHeight);
        }

        /**
         * 以指定分辨率为基准压缩图片，并将压缩后的图片保存在指定的文件路径中
         *
         * @param srcPath   原文件路径
         * @param decPath   压缩后文件的路径（null：压缩后的路径和原文件路径一致）
         * @param imgWidth  压缩后图片的宽度（大概值）
         * @param imgHeight 压缩后图片的高度（大概值）
         * @return 压缩后的bitmap
         */
        static Bitmap getImage(String srcPath, String decPath, int imgWidth, int imgHeight) {
                return getImage(true, srcPath, decPath, imgWidth, imgHeight);
        }

        /**
         * 以指定分辨率为基准压缩图片，并将压缩后的图片保存在指定的文件路径中
         *
         * @param isCompress 是否进行质量压缩
         * @param srcPath    原文件路径
         * @param decPath    压缩后文件的路径（null：压缩后的路径和原文件路径一致）
         * @param imgWidth   压缩后图片的宽度（大概值）
         * @param imgHeight  压缩后图片的高度（大概值）
         * @return 压缩后的bitmap
         */
        public static Bitmap getImage(boolean isCompress, String srcPath, String decPath, int imgWidth, int imgHeight) {
                BitmapFactory.Options newOpts = new BitmapFactory.Options();
                //开始读入图片，此时把options.inJustDecodeBounds 设回true了
                newOpts.inJustDecodeBounds = true;
                //此时返回bm为空
                Bitmap bitmap = BitmapFactory.decodeFile(srcPath, newOpts);
                newOpts.inJustDecodeBounds = false;
                int width = newOpts.outWidth;
                int height = newOpts.outHeight;
                //缩放比。由于是固定比例缩放，只用高或者宽其中一个数据进行计算即可
                int be = 1;//be=1表示不缩放

                if (height > imgHeight || width > imgWidth) {
                        //使用需要的宽高的最大值来计算比率
                        final int suitedValue = imgHeight > imgWidth ? imgHeight : imgWidth;
                        final int heightRatio = Math.round((float) height / (float) suitedValue);
                        final int widthRatio = Math.round((float) width / (float) suitedValue);
                        be = heightRatio > widthRatio ? heightRatio : widthRatio;//用最大
                }

                if (be <= 0)
                        be = 1;
                //设置缩放比例
                newOpts.inSampleSize = be;
                //重新读入图片，注意此时已经把options.inJustDecodeBounds 设回false了
                bitmap = BitmapFactory.decodeFile(srcPath, newOpts);
                if (bitmap == null) {
                        return null;
                }
                bitmap = rotateBitmapByDegree(bitmap, srcPath);
                return bitmap;
        }

}
